package LambdaDemo;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

interface NoParameterNoReturn{
    //无参且无返回值
      void test();
}
interface OneParameterNoReturn{
    //有一个参数无返回值
    void test(int a);
}
interface MultipleParameterNoReturn{
    //有多个参数无返回值
    void test(int a,int b);
}
interface NoParameterReturn{
    //无参且有返回值
    int test();
}
interface OneParameterReturn{
    //有一个参数有返回值
    int  test(int a);
}
interface MultipleParameterReturn{
    //有多个参数有返回值
    int  test(int a,int b);
}
class Test2{
    public void test(){
        System.out.println();
    }

}
public class Test {
    public static void main8(String[] args) {
        //变量捕获在lambda表达式中的使用
          int c = 2;
        c = 10;
      OneParameterReturn oneParameterReturn =  a->{
          System.out.println(c);
          return a;
      };
      //c= 12;
    }
    public static void main7(String[] args) {
        //变量捕获：
        //变量捕获是指在匿名内部类，或lambda表达式中，所使用的变量在此之前与之后不能被修改
        int a = 10;
        a = 20;
           new Test2(){

               public void test2(){
                   System.out.println(a);
                   System.out.println();
               }

        //  a= 30;
           };

    }

    public static void main6(String[] args) {
        //举例：关于HashMap类中的forEach方法。
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Red", 1);
        map.put("Black", 5);
        map.put("BLUE", 2);

        map.forEach(new BiConsumer<String, Integer>() {
                        @Override
                        public void accept(String s, Integer integer) {
                            System.out.println("  key   : " + s + "   value   " + integer);
                        }
                    }
        );
    }
    public static void main(String[] args) {
        //举例： List中的sort方法
     ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(15);
   /* arrayList.sort(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }
    });*/
       // System.out.println(arrayList);
        arrayList.sort(((o1, o2) -> {return o1.compareTo(o2);}));
        System.out.println(arrayList);




    }
    public static void main4(String[] args) {
        //在java集合中与lambda表达式也可配合地使用
        //举例：ArrayList中的forEach语句
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(15);
        //遍历数组可以用迭代器，foreach语句等，也可以采用arrayList本身的方法
        //accept是接口中的抽象方法，将其重写

        //方法1：直接创建匿名内部类调用。
        arrayList.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });

      // 方法2：通过lambda表达式
        //当我们这样编写时，代码很简洁，但是可读性比较差。
        arrayList.forEach((a)->{
            System.out.println(a);
        });

    }
    public static void main3(String[] args) {
        //调用一个无参有返回值的方法
        NoParameterReturn noParameterReturn = ()->10;  //可以不写return 关键字，直接写数值或语句
        System.out.println(noParameterReturn.test());

    }
    public static void main2(String[] args) {
        //再调用有一个参数无返回值的方法、
        //在只有一个参数时，()可以省略
        //{}中只有一条语句时，{}可以省略。
        OneParameterNoReturn oneParameterNoReturn = a ->
            System.out.println(a);

     oneParameterNoReturn.test(10);

    }
    public static void main1(String[] args) {
        //Lambda表达式可用于实现只有一个抽象方法的接口。
       //先实现无返回值无参数的接口
        NoParameterNoReturn noParameterNoReturn1 = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("调用无返回值无参数方法");
            }
        };
        //直接调用方法
        noParameterNoReturn1.test();
      NoParameterNoReturn noParameterNoReturn2 = ()->{ System.out.println("调用无返回值无参数方法");};
      noParameterNoReturn2.test();

    }
}
